/**
 * 判断是否是对象
 * @param {Object} object
 */
export function isObj(object) {
  return object && typeof (object) === 'object' && Object.prototype.toString.call(object).toLowerCase() ===
    '[object object]'
}

/**
 * 判断是否是数组
 * @param {Object} object
 */
export function isArray(object) {
  return object && typeof (object) === 'object' && object.constructor === Array
}

/**
 * 获取对象长度
 * @param {Object} object
 */
export function getLength(object) {
  var count = 0
  for (const i in object) count++
  return count
}

/**
 * 判断两个json对象是否相等
 * @param {Object} objA
 * @param {Object} objB
 */
export function CompareJsonObj(objA, objB) {
  if (!isObj(objA) || !isObj(objB)) return false // 判断类型是否正确
  if (getLength(objA) !== getLength(objB)) return false // 判断长度是否一致
  return CompareObj(objA, objB, true) // 默认为true
}

function CompareObj(objA, objB, flag) {
  if (getLength(objA) !== getLength(objB)) return false
  for (var key in objA) {
    // flag为false，则跳出整个循环
    if (!flag) {
      break
    }
    if (!objB.hasOwnProperty(key)) { // 是否有自身属性，而不是继承的属性
      flag = false
      break
    }
    if (!isArray(objA[key])) { // 子级不是数组时,比较属性值
      if (isObj(objA[key])) {
        if (isObj(objB[key])) {
          if (!flag) {
            break
          } // 这里跳出循环是为了不让递归继续
          flag = CompareObj(objA[key], objB[key], flag)
        } else {
          flag = false
          break
        }
      } else {
        if (String(objB[key]) !== String(objA[key])) { // 排除数字比较的类型差异
          flag = false
          break
        }
      }
    } else {
      if (!isArray(objB[key])) {
        flag = false
        break
      }
      var oA = objA[key]
      var oB = objB[key]
      if (oA.length !== oB.length) {
        flag = false
        break
      }
      for (var k in oA) {
        if (!flag) {
          break
        }// 这里跳出循环是为了不让递归继
        flag = CompareObj(oA[k], oB[k], flag)
      }
    }
  }
  return flag
}

/**
 * json转换成key=value形式
 * @param {Object} data 数据
 * @param {Object} separator 分隔符
 * @param {Object} reverse 是否是key=value转换成json
 */
export function parseJsonToParams(data, separator, reverse) {
  if (separator === undefined) {
    separator = ','
  }
  if (reverse) {
    const arr = data.split(separator)
    const obj = {}
    arr.forEach(item => {
      const arr2 = item.split('=')
      if (arr2.length === 2) {
        obj[arr2[0]] = arr2[1]
      }
    })

    return obj
  }

  if (data === undefined) {
    return ''
  }
  if (typeof data === 'string') {
    data = JSON.parse(data)
  }

  const result = []
  for (const k in data) {
    result.push(k + '=' + data[k])
  }

  return result.join(separator)
}

/**
 * 将json转换为Array
 * @param {Object} json json对象或者字符串
 * @param {Boolean} inserEmpty 是否插入空行
 * @param {String} keyName key对应的名称，默认key
 * @param {String} valName value对应的名称， 默认value
 */
export function parseJsonToArray(options) {
  const defaultOptions = {
    data: {}, // json对象或者字符串
    insertEmpty: false, // 是否插入空行
    keyName: 'key', // key对应的名称，默认key
    valName: 'value', // value对应的名称， 默认value
    customData: undefined // 自定义加入的数据，不会加入到空数据行
  }

  typeof options === 'object' && Object.assign(defaultOptions, options)

  const result = []

  if (defaultOptions.data === undefined) {
    defaultOptions.data = {}
  }
  if (typeof defaultOptions.data === 'string') {
    defaultOptions.data = JSON.parse(defaultOptions.data)
  }

  for (const k in defaultOptions.data) {
    const obj = {
      [defaultOptions.keyName]: k,
      [defaultOptions.valName]: defaultOptions.data[k]
    }
    if (typeof defaultOptions.customData === 'object') {
      for (const key in defaultOptions.customData) {
        obj[key] = defaultOptions.customData[key]
      }
    }
    result.push(obj)
  }

  if (result.length === 0 && defaultOptions.insertEmpty) {
    result.push({
      [defaultOptions.keyName]: '',
      [defaultOptions.valName]: ''
    })
  }
  return result
}
